/**
 * 菜单数据转换工具
 * 用于在树形结构和扁平结构之间转换菜单数据
 */

/**
 * 将树形菜单结构转换为扁平数组（用于导出到Excel）
 * treeData: 树形菜单数据
 * 返回扁平化的菜单数据数组
 */
export function treeToFlat(treeData) {
  const result = [];
  
  function flatten(items, parentPath = '', level = 0) {
    if (!items || !items.length) return;
    
    items.forEach(item => {
      // 构建当前节点的完整路径
      const currentPath = parentPath ? `${parentPath}/${item.id}` : `${item.id}`;
      
      // 创建扁平化的节点
      const flatNode = {
        ...item,
        _parentPath: parentPath || '0', // 父节点路径，用于重建树形结构
        _level: level, // 节点层级，用于显示缩进
        _path: currentPath // 完整路径，用于重建树形结构
      };
      
      // 删除children属性，避免重复数据
      const { children, ...nodeWithoutChildren } = flatNode;
      result.push(nodeWithoutChildren);
      
      // 递归处理子节点
      if (children && children.length > 0) {
        flatten(children, currentPath, level + 1);
      }
    });
  }
  
  flatten(treeData);
  return result;
}

/**
 * 将扁平数组转换回树形菜单结构（用于从Excel导入）
 * flatData: 扁平化的菜单数据数组
 * 返回树形菜单数据
 */
export function flatToTree(flatData) {
  // 检查数据格式并进行预处理
  const processedData = preprocessExcelData(flatData);
  
  // 如果没有_parentPath字段，说明不是从我们导出的Excel导入的
  // 尝试使用id和parentId字段重建树形结构
  if (processedData.length > 0 && !processedData[0]._parentPath) {
    return rebuildTreeByParentId(processedData);
  }
  
  const result = [];
  const nodeMap = {};
  
  // 首先按照层级排序，确保父节点在子节点之前处理
  const sortedData = [...processedData].sort((a, b) => a._level - b._level);
  
  sortedData.forEach(item => {
    // 移除辅助字段
    const { _parentPath, _level, _path, ...node } = item;
    
    // 初始化children数组
    node.children = [];
    
    // 将节点添加到nodeMap
    nodeMap[_path] = node;
    
    // 如果是顶级节点，直接添加到结果数组
    if (_parentPath === '0') {
      result.push(node);
    } else {
      // 否则添加到父节点的children数组
      const parentNode = nodeMap[_parentPath];
      if (parentNode) {
        parentNode.children.push(node);
      } else {
        // 如果找不到父节点，作为顶级节点处理
        result.push(node);
      }
    }
  });
  
  // 清理空的children数组
  cleanEmptyChildren(result);
  
  return result;
}

/**
 * 预处理Excel导入的数据，处理字段名称差异
 * data: Excel导入的原始数据
 * 返回处理后的数据
 */
function preprocessExcelData(data) {
  if (!Array.isArray(data) || data.length === 0) {
    return [];
  }
  
  // 检查第一行数据的字段名，判断是否为Excel导入
  const firstItem = data[0];
  const isExcelImport = 'ID' in firstItem || '菜单名称' in firstItem || '父节点ID' in firstItem;
  
  if (!isExcelImport) {
    return data; // 如果不是Excel导入，直接返回原数据
  }
  
  // 字段映射关系
  const fieldMap = {
    'ID': 'id',
    '父节点ID': 'parentId',
    '菜单名称': 'name',
    '路径': 'path',
    '组件路径': 'component',
    '权限标识': 'perms',
    '图标': 'icon',
    '类型': 'type',
    '排序': 'sort',
    '状态': 'status',
    '层级': '_level'
  };
  
  // 处理Excel导入的数据
  return data.map(item => {
    const newItem = {};
    
    // 转换字段名
    Object.keys(item).forEach(key => {
      const newKey = fieldMap[key] || key;
      newItem[newKey] = item[key];
    });
    
    // 确保ID是数字类型
    if (newItem.id && typeof newItem.id === 'string') {
      newItem.id = parseInt(newItem.id, 10);
    }
    
    // 处理类型字段
    if (newItem.type) {
      if (newItem.type === '菜单') {
        newItem.type = 'M';
      } else if (newItem.type === '目录') {
        newItem.type = 'C';
      } else if (newItem.type === '按钮') {
        newItem.type = 'F';
      }
    }
    
    // 处理状态字段
    if (newItem.status) {
      if (newItem.status === '启用') {
        newItem.status = '1';
      } else if (newItem.status === '禁用') {
        newItem.status = '0';
      }
    }
    
    return newItem;
  });
}

/**
 * 使用id和parentId字段重建树形结构
 * flatData: 扁平化的菜单数据数组
 * 返回树形菜单数据
 */
function rebuildTreeByParentId(flatData) {
  const result = [];
  const nodeMap = {};
  
  // 首先创建所有节点的映射
  flatData.forEach(item => {
    // 确保每个节点都有children数组
    nodeMap[item.id] = { ...item, children: [] };
  });
  
  // 然后构建树形结构
  flatData.forEach(item => {
    const node = nodeMap[item.id];
    
    // 如果有parentId且能找到父节点，则添加到父节点的children
    if (item.parentId && nodeMap[item.parentId]) {
      nodeMap[item.parentId].children.push(node);
    } else {
      // 否则作为顶级节点
      result.push(node);
    }
  });
  
  // 清理空的children数组
  cleanEmptyChildren(result);
  
  return result;
}

/**
 * 清理空的children数组
 * nodes: 节点数组
 */
function cleanEmptyChildren(nodes) {
  if (!nodes) return;
  
  nodes.forEach(node => {
    if (node.children && node.children.length === 0) {
      delete node.children;
    } else if (node.children) {
      cleanEmptyChildren(node.children);
    }
  });
}

/**
 * 生成Excel表头配置
 * 返回表头配置
 */
export function getMenuExcelHeader() {
  return [
    { label: 'ID', prop: 'id' },
    { label: '父节点ID', prop: 'parentId' },
    { label: '菜单名称', prop: 'name' },
    { label: '路径', prop: 'path' },
    { label: '组件路径', prop: 'component' },
    { label: '权限标识', prop: 'perms' },
    { label: '图标', prop: 'icon' },
    { label: '类型', prop: 'type' },
    { label: '排序', prop: 'sort' },
    { label: '状态', prop: 'status' },
    { label: '层级', prop: '_level' }
  ];
}

/**
 * 验证导入的Excel数据是否符合菜单格式
 * data: 导入的数据
 * 返回是否有效
 */
export function validateImportData(data) {
  if (!Array.isArray(data) || data.length === 0) {
    return false;
  }
  
  // 检查必要字段
  const requiredFields = ['id', 'name', 'type'];
  const firstItem = data[0];
  
  return requiredFields.every(field => field in firstItem);
} 